home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / X11R4 / cmds / X / dix / RCS / devices.c,v < prev    next >
Encoding:
Text File  |  1991-02-27  |  32.2 KB  |  1,304 lines
  1. head     1.2;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.2
  10. date     91.02.26.22.13.30;  author kupfer;  state Exp;
  11. branches ;
  12. next     1.1;
  13.  
  14. 1.1
  15. date     90.02.14.15.23.14;  author tve;  state Exp;
  16. branches ;
  17. next     ;
  18.  
  19.  
  20. desc
  21. @Original X11R4 distribution
  22. @
  23.  
  24.  
  25. 1.2
  26. log
  27. @MIT Patch #2.
  28. @
  29. text
  30. @/************************************************************
  31. Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
  32. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  33.  
  34.                         All Rights Reserved
  35.  
  36. Permission to use, copy, modify, and distribute this software and its 
  37. documentation for any purpose and without fee is hereby granted, 
  38. provided that the above copyright notice appear in all copies and that
  39. both that copyright notice and this permission notice appear in 
  40. supporting documentation, and that the names of Digital or MIT not be
  41. used in advertising or publicity pertaining to distribution of the
  42. software without specific, written prior permission.  
  43.  
  44. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  45. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  46. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  47. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  48. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  49. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  50. SOFTWARE.
  51.  
  52. ********************************************************/
  53.  
  54.  
  55. /* $XConsortium: devices.c,v 5.6 90/01/25 14:22:44 rws Exp $ */
  56.  
  57. #include "X.h"
  58. #include "misc.h"
  59. #include "resource.h"
  60. #define NEED_EVENTS
  61. #define NEED_REPLIES
  62. #include "Xproto.h"
  63. #include "windowstr.h"
  64. #include "inputstr.h"
  65. #include "scrnintstr.h"
  66. #include "cursorstr.h"
  67. #include "dixstruct.h"
  68.  
  69. extern InputInfo inputInfo;
  70. extern int (* InitialVector[3]) ();
  71. extern void (* ReplySwapVector[256]) ();
  72. extern void CopySwap32Write(), SwapTimeCoordWrite();
  73. extern void ActivatePointerGrab(), DeactivatePointerGrab();
  74. extern void ActivateKeyboardGrab(), DeactivateKeyboardGrab();
  75. extern Mask EventMaskForClient();
  76.  
  77. DevicePtr
  78. AddInputDevice(deviceProc, autoStart)
  79.     DeviceProc deviceProc;
  80.     Bool autoStart;
  81. {
  82.     register DeviceIntPtr dev;
  83.  
  84.     if (inputInfo.numDevices >= MAX_DEVICES)
  85.     return (DevicePtr)NULL;
  86.     dev = (DeviceIntPtr) xalloc(sizeof(DeviceIntRec));
  87.     if (!dev)
  88.     return (DevicePtr)NULL;
  89.     dev->name = (char *)NULL;
  90.     dev->type = 0;
  91.     dev->id = inputInfo.numDevices;
  92.     inputInfo.numDevices++;
  93.     dev->public.on = FALSE;
  94.     dev->public.processInputProc = NoopDDA;
  95.     dev->public.realInputProc = NoopDDA;
  96.     dev->deviceProc = deviceProc;
  97.     dev->startup = autoStart;
  98.     dev->sync.frozen = FALSE;
  99.     dev->sync.other = NullGrab;
  100.     dev->sync.state = NOT_GRABBED;
  101.     dev->sync.event = (xEvent *) NULL;
  102.     dev->grab = NullGrab;
  103.     dev->fromPassiveGrab = FALSE;
  104.     dev->key = (KeyClassPtr)NULL;
  105.     dev->valuator = (ValuatorClassPtr)NULL;
  106.     dev->button = (ButtonClassPtr)NULL;
  107.     dev->focus = (FocusClassPtr)NULL;
  108.     dev->proximity = (ProximityClassPtr)NULL;
  109.     dev->kbdfeed = (KbdFeedbackPtr)NULL;
  110.     dev->ptrfeed = (PtrFeedbackPtr)NULL;
  111.     dev->intfeed = (IntegerFeedbackPtr)NULL;
  112.     dev->stringfeed = (StringFeedbackPtr)NULL;
  113.     dev->bell = (BellFeedbackPtr)NULL;
  114.     dev->leds = (LedFeedbackPtr)NULL;
  115.     dev->next = inputInfo.off_devices;
  116.     inputInfo.off_devices = dev;
  117.     return &dev->public;
  118. }
  119.  
  120. Bool
  121. EnableDevice(dev)
  122.     register DeviceIntPtr dev;
  123. {
  124.     register DeviceIntPtr *prev;
  125.  
  126.     for (prev = &inputInfo.off_devices;
  127.      *prev && (*prev != dev);
  128.      prev = &(*prev)->next)
  129.     ;
  130.     if ((*prev != dev) || !dev->inited ||
  131.     ((*dev->deviceProc)(dev, DEVICE_ON) != Success))
  132.     return FALSE;
  133.     *prev = dev->next;
  134.     dev->next = inputInfo.devices;
  135.     inputInfo.devices = dev;
  136.     return TRUE;
  137. }
  138.  
  139. Bool
  140. DisableDevice(dev)
  141.     register DeviceIntPtr dev;
  142. {
  143.     register DeviceIntPtr *prev;
  144.  
  145.     for (prev = &inputInfo.devices;
  146.      *prev && (*prev != dev);
  147.      prev = &(*prev)->next)
  148.     ;
  149.     if (*prev != dev)
  150.     return FALSE;
  151.     (void)(*dev->deviceProc)(dev, DEVICE_OFF);
  152.     *prev = dev->next;
  153.     dev->next = inputInfo.off_devices;
  154.     inputInfo.off_devices = dev;
  155.     return TRUE;
  156. }
  157.  
  158. int
  159. InitAndStartDevices()
  160. {
  161.     register DeviceIntPtr dev, next;
  162.  
  163.     for (dev = inputInfo.off_devices; dev; dev = dev->next)
  164.     dev->inited = ((*dev->deviceProc)(dev, DEVICE_INIT) == Success);
  165.     for (dev = inputInfo.off_devices; dev; dev = next)
  166.     {
  167.     next = dev->next;
  168.     if (dev->inited && dev->startup)
  169.         (void)EnableDevice(dev);
  170.     }
  171.     for (dev = inputInfo.devices;
  172.      dev && (dev != inputInfo.keyboard);
  173.      dev = dev->next)
  174.     ;
  175.     if (!dev || (dev != inputInfo.keyboard))
  176.     return BadImplementation;
  177.     for (dev = inputInfo.devices;
  178.      dev && (dev != inputInfo.pointer);
  179.      dev = dev->next)
  180.     ;
  181.     if (!dev || (dev != inputInfo.pointer))
  182.     return BadImplementation;
  183.     return Success;
  184. }
  185.  
  186. static void
  187. CloseDevice(dev)
  188.     register DeviceIntPtr dev;
  189. {
  190.     if (dev->inited)
  191.     (void)(*dev->deviceProc)(dev, DEVICE_CLOSE);
  192.     if (dev->key)
  193.     {
  194.     xfree(dev->key->curKeySyms.map);
  195.     xfree(dev->key->modifierKeyMap);
  196.     xfree(dev->key);
  197.     }
  198.     xfree(dev->valuator);
  199.     xfree(dev->button);
  200.     if (dev->focus)
  201.     {
  202.     xfree(dev->focus->trace);
  203.     xfree(dev->focus);
  204.     }
  205.     xfree(dev->proximity);
  206.     xfree(dev->kbdfeed);
  207.     xfree(dev->ptrfeed);
  208.     xfree(dev->intfeed);
  209.     xfree(dev->stringfeed);
  210.     xfree(dev->bell);
  211.     xfree(dev->leds);
  212.     xfree(dev);
  213. }
  214.  
  215. void
  216. CloseDownDevices()
  217. {
  218.     register DeviceIntPtr dev, next;
  219.  
  220.     for (dev = inputInfo.devices; dev; dev = next)
  221.     {
  222.     next = dev->next;
  223.     CloseDevice(dev);
  224.     }
  225.     for (dev = inputInfo.off_devices; dev; dev = next)
  226.     {
  227.     next = dev->next;
  228.     CloseDevice(dev);
  229.     }
  230. }
  231.  
  232. int
  233. NumMotionEvents()
  234. {
  235.     return inputInfo.pointer->valuator->numMotionEvents;
  236. }
  237.  
  238. void
  239. RegisterPointerDevice(device)
  240.     DevicePtr device;
  241. {
  242.     inputInfo.pointer = (DeviceIntPtr)device;
  243.     device->processInputProc = ProcessPointerEvent;
  244.     device->realInputProc = ProcessPointerEvent;
  245.     ((DeviceIntPtr)device)->ActivateGrab = ActivatePointerGrab;
  246.     ((DeviceIntPtr)device)->DeactivateGrab = DeactivatePointerGrab;
  247. }
  248.  
  249. void
  250. RegisterKeyboardDevice(device)
  251.     DevicePtr device;
  252. {
  253.     inputInfo.keyboard = (DeviceIntPtr)device;
  254.     device->processInputProc = ProcessKeyboardEvent;
  255.     device->realInputProc = ProcessKeyboardEvent;
  256.     ((DeviceIntPtr)device)->ActivateGrab = ActivateKeyboardGrab;
  257.     ((DeviceIntPtr)device)->DeactivateGrab = DeactivateKeyboardGrab;
  258. }
  259.  
  260. DevicePtr
  261. LookupKeyboardDevice()
  262. {
  263.     return &inputInfo.keyboard->public;
  264. }
  265.  
  266. DevicePtr
  267. LookupPointerDevice()
  268. {
  269.     return &inputInfo.pointer->public;
  270. }
  271.  
  272. void
  273. QueryMinMaxKeyCodes(minCode, maxCode)
  274.     KeyCode *minCode, *maxCode;
  275. {
  276.     *minCode = inputInfo.keyboard->key->curKeySyms.minKeyCode;
  277.     *maxCode = inputInfo.keyboard->key->curKeySyms.maxKeyCode;
  278. }
  279.  
  280. Bool
  281. SetKeySymsMap(dst, src)
  282.     register KeySymsPtr dst, src;
  283. {
  284.     int i, j;
  285.     int rowDif = src->minKeyCode - dst->minKeyCode;
  286.            /* if keysym map size changes, grow map first */
  287.  
  288.     if (src->mapWidth < dst->mapWidth)
  289.     {
  290.         for (i = src->minKeyCode; i <= src->maxKeyCode; i++)
  291.     {
  292. #define SI(r, c) (((r-src->minKeyCode)*src->mapWidth) + (c))
  293. #define DI(r, c) (((r - dst->minKeyCode)*dst->mapWidth) + (c))
  294.         for (j = 0; j < src->mapWidth; j++)
  295.         dst->map[DI(i, j)] = src->map[SI(i, j)];
  296.         for (j = src->mapWidth; j < dst->mapWidth; j++)
  297.         dst->map[DI(i, j)] = NoSymbol;
  298. #undef SI
  299. #undef DI
  300.     }
  301.     return TRUE;
  302.     }
  303.     else if (src->mapWidth > dst->mapWidth)
  304.     {
  305.         KeySym *map;
  306.     int bytes = sizeof(KeySym) * src->mapWidth *
  307.             (dst->maxKeyCode - dst->minKeyCode + 1);
  308.         map = (KeySym *)xalloc(bytes);
  309.     if (!map)
  310.         return FALSE;
  311.     bzero((char *)map, bytes);
  312.         if (dst->map)
  313.     {
  314.             for (i = 0; i <= dst->maxKeyCode-dst->minKeyCode; i++)
  315.         bcopy((char *)&dst->map[i*dst->mapWidth],
  316.               (char *)&map[i*src->mapWidth],
  317.               dst->mapWidth * sizeof(KeySym));
  318.         xfree(dst->map);
  319.     }
  320.     dst->mapWidth = src->mapWidth;
  321.     dst->map = map;
  322.     }
  323.     bcopy((char *)src->map,
  324.       (char *)&dst->map[rowDif * dst->mapWidth],
  325.       (int)(src->maxKeyCode - src->minKeyCode + 1) *
  326.       dst->mapWidth * sizeof(KeySym));
  327.     return TRUE;
  328. }
  329.  
  330. static Bool
  331. InitModMap(keyc)
  332.     register KeyClassPtr keyc;
  333. {
  334.     int i, j;
  335.     CARD8 keysPerModifier[8];
  336.     CARD8 mask;
  337.  
  338.     keyc->maxKeysPerModifier = 0;
  339.     for (i = 0; i < 8; i++)
  340.     keysPerModifier[i] = 0;
  341.     for (i = 8; i < MAP_LENGTH; i++)
  342.     {
  343.     for (j = 0, mask = 1; j < 8; j++, mask <<= 1)
  344.     {
  345.         if (mask & keyc->modifierMap[i])
  346.         {
  347.         if (++keysPerModifier[j] > keyc->maxKeysPerModifier)
  348.             keyc->maxKeysPerModifier = keysPerModifier[j];
  349.         }
  350.     }
  351.     }
  352.     keyc->modifierKeyMap = (KeyCode *)xalloc(8*keyc->maxKeysPerModifier);
  353.     if (!keyc->modifierKeyMap && keyc->maxKeysPerModifier)
  354.     return (FALSE);
  355.     bzero((char *)keyc->modifierKeyMap, 8*(int)keyc->maxKeysPerModifier);
  356.     for (i = 0; i < 8; i++)
  357.     keysPerModifier[i] = 0;
  358.     for (i = 8; i < MAP_LENGTH; i++)
  359.     {
  360.     for (j = 0, mask = 1; j < 8; j++, mask <<= 1)
  361.     {
  362.         if (mask & keyc->modifierMap[i])
  363.         {
  364.         keyc->modifierKeyMap[(j*keyc->maxKeysPerModifier) +
  365.                      keysPerModifier[j]] = i;
  366.         keysPerModifier[j]++;
  367.         }
  368.     }
  369.     }
  370.     return TRUE;
  371. }
  372.  
  373. Bool
  374. InitKeyClassDeviceStruct(dev, pKeySyms, pModifiers)
  375.     DeviceIntPtr dev;
  376.     KeySymsPtr pKeySyms;
  377.     CARD8 pModifiers[];
  378. {
  379.     int i;
  380.     register KeyClassPtr keyc;
  381.  
  382.     keyc = (KeyClassPtr)xalloc(sizeof(KeyClassRec));
  383.     if (!keyc)
  384.     return FALSE;
  385.     keyc->curKeySyms.map = (KeySym *)NULL;
  386.     keyc->curKeySyms.mapWidth = 0;
  387.     keyc->curKeySyms.minKeyCode = pKeySyms->minKeyCode;
  388.     keyc->curKeySyms.maxKeyCode = pKeySyms->maxKeyCode;
  389.     keyc->modifierKeyMap = (KeyCode *)NULL;
  390.     keyc->state = 0;
  391.     if (pModifiers)
  392.     bcopy((char *)pModifiers, (char *)keyc->modifierMap, MAP_LENGTH);
  393.     else
  394.     bzero((char *)keyc->modifierMap, MAP_LENGTH);
  395.     bzero((char *)keyc->down, DOWN_LENGTH);
  396.     for (i = 0; i < 8; i++)
  397.     keyc->modifierKeyCount[i] = 0;
  398.     if (!SetKeySymsMap(&keyc->curKeySyms, pKeySyms) || !InitModMap(keyc))
  399.     {
  400.     xfree(keyc->curKeySyms.map);
  401.     xfree(keyc->modifierKeyMap);
  402.     xfree(keyc);
  403.     return FALSE;
  404.     }
  405.     dev->key = keyc;
  406.     return TRUE;
  407. }
  408.  
  409. Bool
  410. InitButtonClassDeviceStruct(dev, numButtons, map)
  411.     register DeviceIntPtr dev;
  412.     int numButtons;
  413.     CARD8 *map;
  414. {
  415.     register ButtonClassPtr butc;
  416.     int i;
  417.  
  418.     butc = (ButtonClassPtr)xalloc(sizeof(ButtonClassRec));
  419.     if (!butc)
  420.     return FALSE;
  421.     butc->numButtons = numButtons;
  422.     for (i = 1; i <= numButtons; i++)
  423.     butc->map[i] = map[i];
  424.     butc->buttonsDown = 0;
  425.     butc->state = 0;
  426.     butc->motionMask = 0;
  427.     bzero((char *)butc->down, DOWN_LENGTH);
  428.     dev->button = butc;
  429.     return TRUE;
  430. }
  431.  
  432. Bool
  433. InitValuatorClassDeviceStruct(dev, numAxes, motionProc, numMotionEvents, mode)
  434.     DeviceIntPtr dev;
  435.     int (*motionProc)();
  436.     int numAxes;
  437.     int numMotionEvents;
  438.     int mode;
  439. {
  440.     register ValuatorClassPtr valc;
  441.  
  442.     valc = (ValuatorClassPtr)xalloc(sizeof(ValuatorClassRec) +
  443.                     numAxes * sizeof(XAxisInfo) +
  444.                     numAxes * sizeof(unsigned short));
  445.     if (!valc)
  446.     return FALSE;
  447.     valc->GetMotionProc = motionProc;
  448.     valc->numMotionEvents = numMotionEvents;
  449.     valc->motionHintWindow = NullWindow;
  450.     valc->numAxes = numAxes;
  451.     valc->mode = mode;
  452.     valc->axes = (XAxisInfoPtr)(valc + 1);
  453.     valc->axisVal = (unsigned short *)(valc->axes +
  454.                        (numAxes * sizeof(XAxisInfo)));
  455.     dev->valuator = valc;
  456.     return TRUE;
  457. }
  458.  
  459. Bool
  460. InitFocusClassDeviceStruct(dev)
  461.     DeviceIntPtr dev;
  462. {
  463.     register FocusClassPtr focc;
  464.  
  465.     focc = (FocusClassPtr)xalloc(sizeof(FocusClassRec));
  466.     if (!focc)
  467.     return FALSE;
  468.     focc->win = PointerRootWin;
  469.     focc->revert = None;
  470.     focc->time = currentTime;
  471.     focc->trace = (WindowPtr *)NULL;
  472.     focc->traceSize = 0;
  473.     focc->traceGood = 0;
  474.     dev->focus = focc;
  475.     return TRUE;
  476. }
  477.  
  478. Bool
  479. InitKbdFeedbackClassDeviceStruct(dev, bellProc, controlProc)
  480.     DeviceIntPtr dev;
  481.     void (*bellProc)();
  482.     void (*controlProc)();
  483. {
  484.     register KbdFeedbackPtr feedc;
  485.  
  486.     feedc = (KbdFeedbackPtr)xalloc(sizeof(KbdFeedbackClassRec));
  487.     if (!feedc)
  488.     return FALSE;
  489.     feedc->BellProc = bellProc;
  490.     feedc->CtrlProc = controlProc;
  491.     feedc->ctrl = defaultKeyboardControl;
  492.     dev->kbdfeed = feedc;
  493.     (*controlProc)(dev, &feedc->ctrl);
  494.     return TRUE;
  495. }
  496.  
  497. Bool
  498. InitPtrFeedbackClassDeviceStruct(dev, controlProc)
  499.     DeviceIntPtr dev;
  500.     void (*controlProc)();
  501. {
  502.     register PtrFeedbackPtr feedc;
  503.  
  504.     feedc = (PtrFeedbackPtr)xalloc(sizeof(PtrFeedbackClassRec));
  505.     if (!feedc)
  506.     return FALSE;
  507.     feedc->CtrlProc = controlProc;
  508.     feedc->ctrl = defaultPointerControl;
  509.     dev->ptrfeed = feedc;
  510.     (*controlProc)(dev, &feedc->ctrl);
  511.     return TRUE;
  512. }
  513.  
  514. Bool
  515. InitPointerDeviceStruct(device, map, numButtons, motionProc, controlProc,
  516.             numMotionEvents)
  517.     DevicePtr device;
  518.     CARD8 *map;
  519.     int numButtons;
  520.     void (*controlProc)();
  521.     int (*motionProc)();
  522.     int numMotionEvents;
  523. {
  524.     DeviceIntPtr dev = (DeviceIntPtr)device;
  525.  
  526.     return(InitButtonClassDeviceStruct(dev, numButtons, map) &&
  527.        InitValuatorClassDeviceStruct(dev, 2, motionProc,
  528.                      numMotionEvents, 0) &&
  529.        InitPtrFeedbackClassDeviceStruct(dev, controlProc));
  530. }
  531.  
  532. Bool
  533. InitKeyboardDeviceStruct(device, pKeySyms, pModifiers, bellProc, controlProc)
  534.     DevicePtr device;
  535.     KeySymsPtr pKeySyms;
  536.     CARD8 pModifiers[];
  537.     void (*bellProc)();
  538.     void (*controlProc)();
  539. {
  540.     DeviceIntPtr dev = (DeviceIntPtr)device;
  541.  
  542.     return(InitKeyClassDeviceStruct(dev, pKeySyms, pModifiers) &&
  543.        InitFocusClassDeviceStruct(dev) &&
  544.        InitKbdFeedbackClassDeviceStruct(dev, bellProc, controlProc));
  545. }
  546.  
  547. int
  548. SendMappingNotify(request, firstKeyCode, count)
  549.     CARD8 request, count;
  550.     KeyCode firstKeyCode;
  551. {
  552.     int i;
  553.     xEvent event;
  554.  
  555.     event.u.u.type = MappingNotify;
  556.     event.u.mappingNotify.request = request;
  557.     if (request == MappingKeyboard)
  558.     {
  559.         event.u.mappingNotify.firstKeyCode = firstKeyCode;
  560.         event.u.mappingNotify.count = count;
  561.     }
  562.     /* 0 is the server client */
  563.     for (i=1; i<currentMaxClients; i++)
  564.         if (clients[i] && ! clients[i]->clientGone &&
  565.         (clients[i]->requestVector != InitialVector))
  566.     {
  567.         event.u.u.sequenceNumber = clients[i]->sequence;
  568.             WriteEventsToClient(clients[i], 1, &event);
  569.     }
  570. }
  571.  
  572. /*
  573.  * n-squared algorithm. n < 255 and don't want to copy the whole thing and
  574.  * sort it to do the checking. How often is it called? Just being lazy?
  575.  */
  576. Bool
  577. BadDeviceMap(buff, length, low, high, errval)
  578.     register BYTE *buff;
  579.     int length;
  580.     unsigned low, high;
  581.     XID *errval;
  582. {
  583.     register int     i, j;
  584.  
  585.     for (i = 0; i < length; i++)
  586.     if (buff[i])               /* only check non-zero elements */
  587.     {
  588.         if ((low > buff[i]) || (high < buff[i]))
  589.         {
  590.         *errval = buff[i];
  591.         return TRUE;
  592.         }
  593.         for (j = i + 1; j < length; j++)
  594.         if (buff[i] == buff[j])
  595.         {
  596.             *errval = buff[i];
  597.             return TRUE;
  598.         }
  599.     }
  600.     return FALSE;
  601. }
  602.  
  603. Bool
  604. AllModifierKeysAreUp(dev, map1, per1, map2, per2)
  605.     register DeviceIntPtr dev;
  606.     register CARD8 *map1, *map2;
  607.     int per1, per2;
  608. {
  609.     register int i, j, k;
  610.     register CARD8 *down = dev->key->down;
  611.  
  612.     for (i = 8; --i >= 0; map2 += per2)
  613.     {
  614.     for (j = per1; --j >= 0; map1++)
  615.     {
  616.         if (*map1 && BitIsOn(down, *map1))
  617.         {
  618.         for (k = per2; (--k >= 0) && (*map1 != map2[k]);)
  619.           ;
  620.         if (k < 0)
  621.             return FALSE;
  622.         }
  623.     }
  624.     }
  625.     return TRUE;
  626. }
  627.  
  628. int 
  629. ProcSetModifierMapping(client)
  630.     ClientPtr client;
  631. {
  632.     xSetModifierMappingReply rep;
  633.     REQUEST(xSetModifierMappingReq);
  634.     KeyCode *inputMap;
  635.     int inputMapLen;
  636.     register int i;
  637.     DeviceIntPtr keybd = inputInfo.keyboard;
  638.     register KeyClassPtr keyc = keybd->key;
  639.     
  640.     REQUEST_AT_LEAST_SIZE(xSetModifierMappingReq);
  641.  
  642.     if (stuff->length != ((stuff->numKeyPerModifier<<1) +
  643.               (sizeof (xSetModifierMappingReq)>>2)))
  644.     return BadLength;
  645.  
  646.     inputMapLen = 8*stuff->numKeyPerModifier;
  647.     inputMap = (KeyCode *)&stuff[1];
  648.  
  649.     /*
  650.      *    Now enforce the restriction that "all of the non-zero keycodes must be
  651.      *    in the range specified by min-keycode and max-keycode in the
  652.      *    connection setup (else a Value error)"
  653.      */
  654.     i = inputMapLen;
  655.     while (i--)
  656.     {
  657.     if (inputMap[i]
  658.         && (inputMap[i] < keyc->curKeySyms.minKeyCode
  659.         || inputMap[i] > keyc->curKeySyms.maxKeyCode))
  660.     {
  661.         client->errorValue = inputMap[i];
  662.         return BadValue;
  663.     }
  664.     }
  665.     rep.type = X_Reply;
  666.     rep.length = 0;
  667.     rep.sequenceNumber = client->sequence;
  668.     rep.success = MappingSuccess;
  669.  
  670.     /*
  671.      *    Now enforce the restriction that none of the old or new
  672.      *    modifier keys may be down while we change the mapping,  and
  673.      *    that the DDX layer likes the choice.
  674.      */
  675.     if (!AllModifierKeysAreUp(keybd, keyc->modifierKeyMap,
  676.                   (int)keyc->maxKeysPerModifier,
  677.                   inputMap, (int)stuff->numKeyPerModifier)
  678.         ||
  679.     !AllModifierKeysAreUp(keybd, inputMap, (int)stuff->numKeyPerModifier,
  680.                   keyc->modifierKeyMap,
  681.                   (int)keyc->maxKeysPerModifier))
  682.     {
  683.     rep.success = MappingBusy;
  684.     }
  685.     else
  686.     {
  687.     for (i = 0; i < inputMapLen; i++)
  688.     {
  689.         if (inputMap[i] && !LegalModifier(inputMap[i], keybd))
  690.         {
  691.         rep.success = MappingFailed;
  692.         break;
  693.         }
  694.     }
  695.     }
  696.  
  697.     if (rep.success == MappingSuccess)
  698.     {
  699.     KeyCode *map;
  700.     /*
  701.      *    Now build the keyboard's modifier bitmap from the
  702.      *    list of keycodes.
  703.      */
  704.     map = (KeyCode *)xalloc(inputMapLen);
  705.     if (!map)
  706.         return BadAlloc;
  707.     if (keyc->modifierKeyMap)
  708.         xfree(keyc->modifierKeyMap);
  709.     keyc->modifierKeyMap = map;
  710.     bcopy((char *)inputMap, (char *)map, inputMapLen);
  711.  
  712.     keyc->maxKeysPerModifier = stuff->numKeyPerModifier;
  713.     for (i = 0; i < MAP_LENGTH; i++)
  714.         keyc->modifierMap[i] = 0;
  715.     for (i = 0; i < inputMapLen; i++)
  716.     {
  717.         if (inputMap[i])
  718.         keyc->modifierMap[inputMap[i]] |=
  719.             (1<<(i/keyc->maxKeysPerModifier));
  720.     }
  721.     }
  722.  
  723.     WriteReplyToClient(client, sizeof(xSetModifierMappingReply), &rep);
  724.  
  725.     if (rep.success == MappingSuccess)
  726.         SendMappingNotify(MappingModifier, 0, 0);
  727.     return(client->noClientException);
  728. }
  729.  
  730. int
  731. ProcGetModifierMapping(client)
  732.     ClientPtr client;
  733. {
  734.     xGetModifierMappingReply rep;
  735.     REQUEST(xReq);
  736.     register KeyClassPtr keyc = inputInfo.keyboard->key;
  737.  
  738.     REQUEST_SIZE_MATCH(xReq);
  739.     rep.type = X_Reply;
  740.     rep.numKeyPerModifier = keyc->maxKeysPerModifier;
  741.     rep.sequenceNumber = client->sequence;
  742.     /* length counts 4 byte quantities - there are 8 modifiers 1 byte big */
  743.     rep.length = keyc->maxKeysPerModifier << 1;
  744.  
  745.     WriteReplyToClient(client, sizeof(xGetModifierMappingReply), &rep);
  746.  
  747.     /* Use the (modified by DDX) map that SetModifierMapping passed in */
  748.     (void)WriteToClient(client, (int)(keyc->maxKeysPerModifier << 3),
  749.             (char *)keyc->modifierKeyMap);
  750.     return client->noClientException;
  751. }
  752.  
  753. int
  754. ProcChangeKeyboardMapping(client)
  755.     ClientPtr client;
  756. {
  757.     REQUEST(xChangeKeyboardMappingReq);
  758.     unsigned len;
  759.     KeySymsRec keysyms;
  760.     register KeySymsPtr curKeySyms = &inputInfo.keyboard->key->curKeySyms;
  761.     REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq);
  762.  
  763.     len = stuff->length - (sizeof(xChangeKeyboardMappingReq) >> 2);  
  764.     if (len != (stuff->keyCodes * stuff->keySymsPerKeyCode))
  765.             return BadLength;
  766.     if ((stuff->firstKeyCode < curKeySyms->minKeyCode) ||
  767.     (stuff->firstKeyCode + stuff->keyCodes - 1 > curKeySyms->maxKeyCode))
  768.     {
  769.         client->errorValue = stuff->firstKeyCode;
  770.         return BadValue;
  771.     }
  772.     if (stuff->keySymsPerKeyCode == 0)
  773.     {
  774.         client->errorValue = 0;
  775.             return BadValue;
  776.     }
  777.     keysyms.minKeyCode = stuff->firstKeyCode;
  778.     keysyms.maxKeyCode = stuff->firstKeyCode + stuff->keyCodes - 1;
  779.     keysyms.mapWidth = stuff->keySymsPerKeyCode;
  780.     keysyms.map = (KeySym *)&stuff[1];
  781.     if (!SetKeySymsMap(curKeySyms, &keysyms))
  782.     return BadAlloc;
  783.     SendMappingNotify(MappingKeyboard, stuff->firstKeyCode, stuff->keyCodes);
  784.     return client->noClientException;
  785.  
  786. }
  787.  
  788. int
  789. ProcSetPointerMapping(client)
  790.     ClientPtr client;
  791. {
  792.     REQUEST(xSetPointerMappingReq);
  793.     BYTE *map;
  794.     xSetPointerMappingReply rep;
  795.     register int i;
  796.     DeviceIntPtr mouse = inputInfo.pointer;
  797.  
  798.     REQUEST_AT_LEAST_SIZE(xSetPointerMappingReq);
  799.     if (stuff->length != (sizeof(xSetPointerMappingReq) + stuff->nElts + 3)>>2)
  800.     return BadLength;
  801.     rep.type = X_Reply;
  802.     rep.length = 0;
  803.     rep.sequenceNumber = client->sequence;
  804.     rep.success = MappingSuccess;
  805.     map = (BYTE *)&stuff[1];
  806.     if (stuff->nElts != mouse->button->numButtons)
  807.     {
  808.     client->errorValue = stuff->nElts;
  809.     return BadValue;
  810.     }
  811.     if (BadDeviceMap(&map[0], (int)stuff->nElts, 1, 255, &client->errorValue))
  812.     return BadValue;
  813.     for (i=0; i < stuff->nElts; i++)
  814.     if ((mouse->button->map[i + 1] != map[i]) &&
  815.         BitIsOn(mouse->button->down, i + 1))
  816.     {
  817.             rep.success = MappingBusy;
  818.         WriteReplyToClient(client, sizeof(xSetPointerMappingReply), &rep);
  819.             return Success;
  820.     }
  821.     for (i = 0; i < stuff->nElts; i++)
  822.     mouse->button->map[i + 1] = map[i];
  823.     WriteReplyToClient(client, sizeof(xSetPointerMappingReply), &rep);
  824.     SendMappingNotify(MappingPointer, 0, 0);
  825.     return Success;
  826. }
  827.  
  828. int
  829. ProcGetKeyboardMapping(client)
  830.     ClientPtr client;
  831. {
  832.     xGetKeyboardMappingReply rep;
  833.     REQUEST(xGetKeyboardMappingReq);
  834.     KeySymsPtr curKeySyms = &inputInfo.keyboard->key->curKeySyms;
  835.  
  836.     REQUEST_SIZE_MATCH(xGetKeyboardMappingReq);
  837.  
  838.     if ((stuff->firstKeyCode < curKeySyms->minKeyCode) ||
  839.         (stuff->firstKeyCode > curKeySyms->maxKeyCode))
  840.     {
  841.     client->errorValue = stuff->firstKeyCode;
  842.     return BadValue;
  843.     }
  844.     if (stuff->firstKeyCode + stuff->count > curKeySyms->maxKeyCode + 1)
  845.     {
  846.     client->errorValue = stuff->count;
  847.         return BadValue;
  848.     }
  849.  
  850.     rep.type = X_Reply;
  851.     rep.sequenceNumber = client->sequence;
  852.     rep.keySymsPerKeyCode = curKeySyms->mapWidth;
  853.     /* length is a count of 4 byte quantities and KeySyms are 4 bytes */
  854.     rep.length = (curKeySyms->mapWidth * stuff->count);
  855.     WriteReplyToClient(client, sizeof(xGetKeyboardMappingReply), &rep);
  856.     client->pSwapReplyFunc = CopySwap32Write;
  857.     WriteSwappedDataToClient(
  858.     client,
  859.     curKeySyms->mapWidth * stuff->count * sizeof(KeySym),
  860.     &curKeySyms->map[(stuff->firstKeyCode - curKeySyms->minKeyCode) *
  861.              curKeySyms->mapWidth]);
  862.  
  863.     return client->noClientException;
  864. }
  865.  
  866. int
  867. ProcGetPointerMapping(client)
  868.     ClientPtr client;
  869. {
  870.     xGetPointerMappingReply rep;
  871.     REQUEST(xReq);
  872.     ButtonClassPtr butc = inputInfo.pointer->button;
  873.  
  874.     REQUEST_SIZE_MATCH(xReq);
  875.     rep.type = X_Reply;
  876.     rep.sequenceNumber = client->sequence;
  877.     rep.nElts = butc->numButtons;
  878.     rep.length = (rep.nElts + (4-1))/4;
  879.     WriteReplyToClient(client, sizeof(xGetPointerMappingReply), &rep);
  880.     (void)WriteToClient(client, (int)rep.nElts, (char *)&butc->map[1]);
  881.     return Success;    
  882. }
  883.  
  884. void
  885. NoteLedState(keybd, led, on)
  886.     DeviceIntPtr keybd;
  887.     int        led;
  888.     Bool    on;
  889. {
  890.     KeybdCtrl *ctrl = &keybd->kbdfeed->ctrl;
  891.     if (on)
  892.     ctrl->leds |= ((Leds)1 << (led - 1));
  893.     else
  894.     ctrl->leds &= ~((Leds)1 << (led - 1));
  895. }
  896.  
  897. int
  898. Ones(mask)                /* HACKMEM 169 */
  899.     Mask mask;
  900. {
  901.     register Mask y;
  902.  
  903.     y = (mask >> 1) &033333333333;
  904.     y = mask - y - ((y >>1) & 033333333333);
  905.     return (((y + (y >> 3)) & 030707070707) % 077);
  906. }
  907.  
  908. int
  909. ProcChangeKeyboardControl (client)
  910.     ClientPtr client;
  911. {
  912. #define DO_ALL    (-1)
  913.     KeybdCtrl ctrl;
  914.     DeviceIntPtr keybd = inputInfo.keyboard;
  915.     XID *vlist;
  916.     int t;
  917.     int led = DO_ALL;
  918.     int key = DO_ALL;
  919.     BITS32 vmask, index;
  920.     int mask, i;
  921.     REQUEST(xChangeKeyboardControlReq);
  922.  
  923.     REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);
  924.     vmask = stuff->mask;
  925.     if (stuff->length !=(sizeof(xChangeKeyboardControlReq)>>2) + Ones(vmask))
  926.     return BadLength;
  927.     vlist = (XID *)&stuff[1];        /* first word of values */
  928.     ctrl = keybd->kbdfeed->ctrl;
  929.     while (vmask)
  930.     {
  931.     index = (BITS32) lowbit (vmask);
  932.     vmask &= ~index;
  933.     switch (index)
  934.     {
  935.     case KBKeyClickPercent: 
  936.         t = (INT8)*vlist;
  937.         vlist++;
  938.         if (t == -1)
  939.         t = defaultKeyboardControl.click;
  940.         else if (t < 0 || t > 100)
  941.         {
  942.         client->errorValue = t;
  943.         return BadValue;
  944.         }
  945.         ctrl.click = t;
  946.         break;
  947.     case KBBellPercent:
  948.         t = (INT8)*vlist;
  949.         vlist++;
  950.         if (t == -1)
  951.         t = defaultKeyboardControl.bell;
  952.         else if (t < 0 || t > 100)
  953.         {
  954.         client->errorValue = t;
  955.         return BadValue;
  956.         }
  957.         ctrl.bell = t;
  958.         break;
  959.     case KBBellPitch:
  960.         t = (INT16)*vlist;
  961.         vlist++;
  962.         if (t == -1)
  963.         t = defaultKeyboardControl.bell_pitch;
  964.         else if (t < 0)
  965.         {
  966.         client->errorValue = t;
  967.         return BadValue;
  968.         }
  969.         ctrl.bell_pitch = t;
  970.         break;
  971.     case KBBellDuration:
  972.         t = (INT16)*vlist;
  973.         vlist++;
  974.         if (t == -1)
  975.         t = defaultKeyboardControl.bell_duration;
  976.         else if (t < 0)
  977.         {
  978.         client->errorValue = t;
  979.         return BadValue;
  980.         }
  981.         ctrl.bell_duration = t;
  982.         break;
  983.     case KBLed:
  984.         led = (CARD8)*vlist;
  985.         vlist++;
  986.         if (led < 1 || led > 32)
  987.         {
  988.         client->errorValue = led;
  989.         return BadValue;
  990.         }
  991.         if (!(stuff->mask & KBLedMode))
  992.         return BadMatch;
  993.         break;
  994.     case KBLedMode:
  995.         t = (CARD8)*vlist;
  996.         vlist++;
  997.         if (t == LedModeOff)
  998.         {
  999.         if (led == DO_ALL)
  1000.             ctrl.leds = 0x0;
  1001.         else
  1002.             ctrl.leds &= ~(((Leds)(1)) << (led - 1));
  1003.         }
  1004.         else if (t == LedModeOn)
  1005.         {
  1006.         if (led == DO_ALL)
  1007.             ctrl.leds = ~0L;
  1008.         else
  1009.             ctrl.leds |= (((Leds)(1)) << (led - 1));
  1010.         }
  1011.         else
  1012.         {
  1013.         client->errorValue = t;
  1014.         return BadValue;
  1015.         }
  1016.         break;
  1017.     case KBKey:
  1018.         key = (KeyCode)*vlist;
  1019.         vlist++;
  1020.         if (key < 8 || key > 255)
  1021.         {
  1022.         client->errorValue = key;
  1023.         return BadValue;
  1024.         }
  1025.         if (!(stuff->mask & KBAutoRepeatMode))
  1026.         return BadMatch;
  1027.         break;
  1028.     case KBAutoRepeatMode:
  1029.         i = (key >> 3);
  1030.         mask = (1 << (key & 7));
  1031.         t = (CARD8)*vlist;
  1032.         vlist++;
  1033.         if (t == AutoRepeatModeOff)
  1034.         {
  1035.         if (key == DO_ALL)
  1036.             ctrl.autoRepeat = FALSE;
  1037.         else
  1038.             ctrl.autoRepeats[i] &= ~mask;
  1039.         }
  1040.         else if (t == AutoRepeatModeOn)
  1041.         {
  1042.         if (key == DO_ALL)
  1043.             ctrl.autoRepeat = TRUE;
  1044.         else
  1045.             ctrl.autoRepeats[i] |= mask;
  1046.         }
  1047.         else if (t == AutoRepeatModeDefault)
  1048.         {
  1049.         if (key == DO_ALL)
  1050.             ctrl.autoRepeat = defaultKeyboardControl.autoRepeat;
  1051.         else
  1052.             ctrl.autoRepeats[i] &= ~mask;
  1053.             ctrl.autoRepeats[i] =
  1054.                 (ctrl.autoRepeats[i] & ~mask) |
  1055.                 (defaultKeyboardControl.autoRepeats[i] & mask);
  1056.         }
  1057.         else
  1058.         {
  1059.         client->errorValue = t;
  1060.         return BadValue;
  1061.         }
  1062.         break;
  1063.     default:
  1064.         client->errorValue = stuff->mask;
  1065.         return BadValue;
  1066.     }
  1067.     }
  1068.     keybd->kbdfeed->ctrl = ctrl;
  1069.     (*keybd->kbdfeed->CtrlProc)(keybd, &keybd->kbdfeed->ctrl);
  1070.     return Success;
  1071. #undef DO_ALL
  1072. } 
  1073.  
  1074. int
  1075. ProcGetKeyboardControl (client)
  1076.     ClientPtr client;
  1077. {
  1078.     int i;
  1079.     register KeybdCtrl *ctrl = &inputInfo.keyboard->kbdfeed->ctrl;
  1080.     xGetKeyboardControlReply rep;
  1081.     REQUEST(xReq);
  1082.  
  1083.     REQUEST_SIZE_MATCH(xReq);
  1084.     rep.type = X_Reply;
  1085.     rep.length = 5;
  1086.     rep.sequenceNumber = client->sequence;
  1087.     rep.globalAutoRepeat = ctrl->autoRepeat;
  1088.     rep.keyClickPercent = ctrl->click;
  1089.     rep.bellPercent = ctrl->bell;
  1090.     rep.bellPitch = ctrl->bell_pitch;
  1091.     rep.bellDuration = ctrl->bell_duration;
  1092.     rep.ledMask = ctrl->leds;
  1093.     for (i = 0; i < 32; i++)
  1094.     rep.map[i] = ctrl->autoRepeats[i];
  1095.     WriteReplyToClient(client, sizeof(xGetKeyboardControlReply), &rep);
  1096.     return Success;
  1097. } 
  1098.  
  1099. int
  1100. ProcBell(client)
  1101.     ClientPtr client;
  1102. {
  1103.     register DeviceIntPtr keybd = inputInfo.keyboard;
  1104.     int base = keybd->kbdfeed->ctrl.bell;
  1105.     int newpercent;
  1106.     REQUEST(xBellReq);
  1107.     REQUEST_SIZE_MATCH(xBellReq);
  1108.     if (stuff->percent < -100 || stuff->percent > 100)
  1109.     {
  1110.     client->errorValue = stuff->percent;
  1111.     return BadValue;
  1112.     }
  1113.     newpercent = (base * stuff->percent) / 100;
  1114.     if (stuff->percent < 0)
  1115.         newpercent = base + newpercent;
  1116.     else
  1117.         newpercent = base - newpercent + stuff->percent;
  1118.     (*keybd->kbdfeed->BellProc)(newpercent, keybd);
  1119.     return Success;
  1120. } 
  1121.  
  1122. int
  1123. ProcChangePointerControl(client)
  1124.     ClientPtr client;
  1125. {
  1126.     DeviceIntPtr mouse = inputInfo.pointer;
  1127.     PtrCtrl ctrl;        /* might get BadValue part way through */
  1128.     REQUEST(xChangePointerControlReq);
  1129.  
  1130.     REQUEST_SIZE_MATCH(xChangePointerControlReq);
  1131.     ctrl = mouse->ptrfeed->ctrl;
  1132.     if (stuff->doAccel)
  1133.     {
  1134.     if (stuff->accelNum == -1)
  1135.         ctrl.num = defaultPointerControl.num;
  1136.     else if (stuff->accelNum < 0)
  1137.     {
  1138.         client->errorValue = stuff->accelNum;
  1139.         return BadValue;
  1140.     }
  1141.     else ctrl.num = stuff->accelNum;
  1142.     if (stuff->accelDenum == -1)
  1143.         ctrl.den = defaultPointerControl.den;
  1144.     else if (stuff->accelDenum <= 0)
  1145.     {
  1146.         client->errorValue = stuff->accelDenum;
  1147.         return BadValue;
  1148.     }
  1149.     else ctrl.den = stuff->accelDenum;
  1150.     }
  1151.     if (stuff->doThresh)
  1152.     {
  1153.     if (stuff->threshold == -1)
  1154.         ctrl.threshold = defaultPointerControl.threshold;
  1155.     else if (stuff->threshold < 0)
  1156.     {
  1157.         client->errorValue = stuff->threshold;
  1158.         return BadValue;
  1159.     }
  1160.     else ctrl.threshold = stuff->threshold;
  1161.     }
  1162.     mouse->ptrfeed->ctrl = ctrl;
  1163.     (*mouse->ptrfeed->CtrlProc)(mouse, &mouse->ptrfeed->ctrl);
  1164.     return Success;
  1165. } 
  1166.  
  1167. int
  1168. ProcGetPointerControl(client)
  1169.     ClientPtr client;
  1170. {
  1171.     register PtrCtrl *ctrl = &inputInfo.pointer->ptrfeed->ctrl;
  1172.     REQUEST(xReq);
  1173.     xGetPointerControlReply rep;
  1174.  
  1175.     REQUEST_SIZE_MATCH(xReq);
  1176.     rep.type = X_Reply;
  1177.     rep.length = 0;
  1178.     rep.sequenceNumber = client->sequence;
  1179.     rep.threshold = ctrl->threshold;
  1180.     rep.accelNumerator = ctrl->num;
  1181.     rep.accelDenominator = ctrl->den;
  1182.     WriteReplyToClient(client, sizeof(xGenericReply), &rep);
  1183.     return Success;
  1184. }
  1185.  
  1186. void
  1187. MaybeStopHint(dev, client)
  1188.     register DeviceIntPtr dev;
  1189.     ClientPtr client;
  1190. {
  1191.     GrabPtr grab = dev->grab;
  1192.  
  1193.     if ((grab && SameClient(grab, client) &&
  1194.      ((grab->eventMask & PointerMotionHintMask) ||
  1195.       (grab->ownerEvents &&
  1196.        (EventMaskForClient(dev->valuator->motionHintWindow, client) &
  1197.         PointerMotionHintMask)))) ||
  1198.     (!grab &&
  1199.      (EventMaskForClient(dev->valuator->motionHintWindow, client) &
  1200.       PointerMotionHintMask)))
  1201.     dev->valuator->motionHintWindow = NullWindow;
  1202. }
  1203.  
  1204. int
  1205. ProcGetMotionEvents(client)
  1206.     ClientPtr client;
  1207. {
  1208.     WindowPtr pWin;
  1209.     xTimecoord * coords = (xTimecoord *) NULL;
  1210.     xGetMotionEventsReply rep;
  1211.     int     i, count, xmin, xmax, ymin, ymax;
  1212.     unsigned long nEvents;
  1213.     DeviceIntPtr mouse = inputInfo.pointer;
  1214.     TimeStamp start, stop;
  1215.     REQUEST(xGetMotionEventsReq);
  1216.  
  1217.     REQUEST_SIZE_MATCH(xGetMotionEventsReq);
  1218.     pWin = LookupWindow(stuff->window, client);
  1219.     if (!pWin)
  1220.     return BadWindow;
  1221.     if (mouse->valuator->motionHintWindow)
  1222.     MaybeStopHint(mouse, client);
  1223.     rep.type = X_Reply;
  1224.     rep.sequenceNumber = client->sequence;
  1225.     nEvents = 0;
  1226.     start = ClientTimeToServerTime(stuff->start);
  1227.     stop = ClientTimeToServerTime(stuff->stop);
  1228.     if ((CompareTimeStamps(start, stop) != LATER) &&
  1229.     (CompareTimeStamps(start, currentTime) != LATER) &&
  1230.     mouse->valuator->numMotionEvents)
  1231.     {
  1232.     if (CompareTimeStamps(stop, currentTime) == LATER)
  1233.         stop = currentTime;
  1234.     coords = (xTimecoord *)ALLOCATE_LOCAL(mouse->valuator->numMotionEvents
  1235.                           * sizeof(xTimecoord));
  1236.     if (!coords)
  1237.         return BadAlloc;
  1238.     count = (*mouse->valuator->GetMotionProc) (mouse, coords,
  1239.                            start.milliseconds,
  1240.                            stop.milliseconds,
  1241.                            pWin->drawable.pScreen);
  1242.     xmin = pWin->drawable.x - wBorderWidth (pWin);
  1243.     xmax = pWin->drawable.x + (int)pWin->drawable.width +
  1244.         wBorderWidth (pWin);
  1245.     ymin = pWin->drawable.y - wBorderWidth (pWin);
  1246.     ymax = pWin->drawable.y + (int)pWin->drawable.height +
  1247.         wBorderWidth (pWin);
  1248.     for (i = 0; i < count; i++)
  1249.         if ((xmin <= coords[i].x) && (coords[i].x < xmax) &&
  1250.             (ymin <= coords[i].y) && (coords[i].y < ymax))
  1251.         {
  1252.         coords[nEvents].x = coords[i].x - pWin->drawable.x;
  1253.         coords[nEvents].y = coords[i].y - pWin->drawable.y;
  1254.         nEvents++;
  1255.         }
  1256.     }
  1257.     rep.length = nEvents * (sizeof(xTimecoord) >> 2);
  1258.     rep.nEvents = nEvents;
  1259.     WriteReplyToClient(client, sizeof(xGetMotionEventsReply), &rep);
  1260.     if (nEvents)
  1261.     {
  1262.     client->pSwapReplyFunc = SwapTimeCoordWrite;
  1263.     WriteSwappedDataToClient(client, nEvents * sizeof(xTimecoord),
  1264.                  (char *)coords);
  1265.     }
  1266.     if (coords)
  1267.     DEALLOCATE_LOCAL(coords);
  1268.     return Success;
  1269. }
  1270.  
  1271. int
  1272. ProcQueryKeymap(client)
  1273.     ClientPtr client;
  1274. {
  1275.     xQueryKeymapReply rep;
  1276.     int i;
  1277.     CARD8 *down = inputInfo.keyboard->key->down;
  1278.  
  1279.     rep.type = X_Reply;
  1280.     rep.sequenceNumber = client->sequence;
  1281.     rep.length = 2;
  1282.     for (i = 0; i<32; i++)
  1283.     rep.map[i] = down[i];
  1284.     WriteReplyToClient(client, sizeof(xQueryKeymapReply), &rep);
  1285.     return Success;
  1286. }
  1287.  
  1288. @
  1289.  
  1290.  
  1291. 1.1
  1292. log
  1293. @Initial revision
  1294. @
  1295. text
  1296. @d26 1
  1297. a26 1
  1298. /* $XConsortium: devices.c,v 5.5 89/11/07 10:45:09 rws Exp $ */
  1299. d41 1
  1300. d535 2
  1301. a536 1
  1302.         if (clients[i] && ! clients[i]->clientGone)
  1303. @
  1304.